home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibcalc.arc / DISPLAY.PAS < prev    next >
Pascal/Delphi Source File  |  1985-03-07  |  5KB  |  125 lines
  1. (*--------------------------------------------------------------------------*)
  2. (*                 DisplayInt  -- Display integer value                     *)
  3. (*--------------------------------------------------------------------------*)
  4.  
  5. PROCEDURE DisplayInt( i, b : INTEGER );
  6.  
  7. (*--------------------------------------------------------------------------*)
  8. (*                                                                          *)
  9. (*     Procedure:  DisplayInt                                               *)
  10. (*                                                                          *)
  11. (*     Purpose:    Displays integer using specified base.                   *)
  12. (*                                                                          *)
  13. (*     Calling Sequence:                                                    *)
  14. (*                                                                          *)
  15. (*        DisplayInt( i , b : INTEGER );                                    *)
  16. (*                                                                          *)
  17. (*           i   --- the integer to be displayed                            *)
  18. (*           b   --- the base to be used in conversion                      *)
  19. (*                                                                          *)
  20. (*     Calls:  none                                                         *)
  21. (*                                                                          *)
  22. (*--------------------------------------------------------------------------*)
  23.  
  24. VAR
  25.    buf  : ARRAY [1..20] OF CHAR;
  26.    j    : INTEGER;
  27.    sign : CHAR;
  28.    dig  : INTEGER;
  29.  
  30. BEGIN (* DisplayInt *)
  31.                                    (* Remember sign of number *)
  32.    sign := ' ';
  33.  
  34.    IF i < 0 THEN
  35.       BEGIN
  36.          sign := '-';
  37.          i    := -i
  38.       END;
  39.  
  40.    j := 0;
  41.                                    (* Get display form of number,  *)
  42.                                    (* one digit at a time.         *)
  43.    WHILE i > 0 DO
  44.       BEGIN
  45.          j   := j + 1;
  46.          dig := i MOD b;
  47.          i   := i DIV b;
  48.          IF dig < 10 THEN
  49.             buf[j] := CHR( dig + ORD('0') )
  50.          ELSE
  51.             buf[j] := CHR( dig - 10 + ORD('A') )
  52.       END;
  53.  
  54.                                     (* Ensure hard zero is output as '0' *)
  55.    IF j = 0 THEN
  56.       BEGIN
  57.          buf[1] := '0';
  58.          j := 1;
  59.       END;
  60.                                     (* Display the converted digits and sign *)
  61.    WRITE(' ':19-j,sign);
  62.  
  63.    FOR j := j DOWNTO 1 DO WRITE(buf[j]);
  64.  
  65. END   (* DisplayInt *);
  66.  
  67. (*--------------------------------------------------------------------------*)
  68. (*                    Display  -- Display value of variable                 *)
  69. (*--------------------------------------------------------------------------*)
  70.  
  71. PROCEDURE Display( lab: CHAR; VAR v: valuety );
  72.  
  73. (*--------------------------------------------------------------------------*)
  74. (*                                                                          *)
  75. (*     Procedure:  Display                                                  *)
  76. (*                                                                          *)
  77. (*     Purpose:    Displays value of variable.                              *)
  78. (*                                                                          *)
  79. (*     Calling Sequence:                                                    *)
  80. (*                                                                          *)
  81. (*        Display( lab: CHAR; VAR v: valuety );                             *)
  82. (*                                                                          *)
  83. (*           lab --- the variable to be displayed                           *)
  84. (*           v   --- the record containing the value of the variable        *)
  85. (*                                                                          *)
  86. (*     Calls:                                                               *)
  87. (*                                                                          *)
  88. (*        DisplayInt                                                        *)
  89. (*        ABS                                                               *)
  90. (*        Log10                                                             *)
  91. (*                                                                          *)
  92. (*--------------------------------------------------------------------------*)
  93.  
  94. BEGIN  (* Display *)
  95.  
  96.                                    (* Write name of variable *)
  97.    WRITE(lab,' ');
  98.  
  99.                                    (* Check variable type *)
  100.    WITH v DO
  101.  
  102.       CASE typ OF
  103.                                    (* Display integer in dec, oct, hex *)
  104.          int: BEGIN
  105.                  DisplayInt( i , 10 );
  106.                  DisplayInt( i ,  8 );
  107.                  WRITE('B');
  108.                  DisplayInt( i , 16 );
  109.                  WRITELN('X');
  110.               END;
  111.  
  112.                                    (* Display real in fractional, expon. *)
  113.          rea: IF r <> 0.0 THEN
  114.                  BEGIN
  115.                     IF Log10( ABS ( r ) ) < ( 18 - FRAC ) THEN
  116.                        WRITE(r:20:FRAC,'  ');
  117.                     WRITELN(r:20);
  118.                  END
  119.               ELSE
  120.                  WRITELN(0:20);
  121.  
  122.       END  (* CASE *);
  123.  
  124. END  (* Display *);
  125.